/**
 * 地址选择组件
 * @component region-picker
 * @author WeChat Mini Program Team
 * @since 2025-08-16
 */

const RegionService = require('../../services/region')

Component({
  /**
   * 组件的属性列表
   */
  properties: {
    // 是否显示选择器
    show: {
      type: Boolean,
      value: false
    },
    // 默认选中的区域路径
    defaultValue: {
      type: Array,
      value: []
    },
    // 选择层级 1-省 2-市 3-区 4-街道 5-小区 6-楼栋 7-门牌
    maxLevel: {
      type: Number,
      value: 5
    }
  },

  /**
   * 组件的初始数据
   */
  data: {
    loading: false,
    currentLevel: 1,
    selectedId: null,
    currentList: [],
    
    // 选择路径
    selectedPath: [],
    
    // 标签页配置
    tabs: [
      { level: 1, placeholder: '请选择省份', name: '' },
      { level: 2, placeholder: '请选择城市', name: '' },
      { level: 3, placeholder: '请选择区县', name: '' },
      { level: 4, placeholder: '请选择街道', name: '' },
      { level: 5, placeholder: '请选择小区', name: '' },
      { level: 6, placeholder: '请选择楼栋', name: '' },
      { level: 7, placeholder: '请选择门牌', name: '' }
    ],
    
    // 各级数据缓存
    regionsCache: {
      1: [], // 省份
      2: [], // 城市
      3: [], // 区县
      4: [], // 街道
      5: [], // 小区
      6: [], // 楼栋
      7: []  // 门牌
    }
  },

  /**
   * 组件生命周期
   */
  lifetimes: {
    attached() {
      this.initData()
    }
  },

  /**
   * 监听属性变化
   */
  observers: {
    'show': function(show) {
      if (show) {
        this.initData()
      }
    },
    'defaultValue': function(value) {
      if (value && value.length > 0) {
        this.setDefaultValue(value)
      }
    }
  },

  /**
   * 组件的方法列表
   */
  methods: {
    
    /**
     * 初始化数据
     */
    async initData() {
      // 重置状态
      this.setData({
        currentLevel: 1,
        selectedId: null,
        selectedPath: [],
        currentList: []
      })
      
      // 加载省份数据
      await this.loadRegionData(1)
    },
    
    /**
     * 设置默认值
     */
    async setDefaultValue(path) {
      if (!path || path.length === 0) return
      
      try {
        this.setData({ loading: true })
        
        const selectedPath = []
        let currentLevel = 1
        
        for (let i = 0; i < path.length && i < this.data.maxLevel; i++) {
          const region = path[i]
          selectedPath.push(region)
          
          // 更新标签页名称
          const tabs = this.data.tabs
          tabs[i].name = region.name
          
          currentLevel = i + 2 // 下一级
        }
        
        this.setData({
          selectedPath,
          currentLevel: Math.min(currentLevel, this.data.maxLevel),
          tabs
        })
        
        // 加载当前级别数据
        await this.loadRegionData(this.data.currentLevel)
        
      } catch (error) {
        console.error('设置默认值失败:', error)
      } finally {
        this.setData({ loading: false })
      }
    },
    
    /**
     * 加载区域数据
     */
    async loadRegionData(level, parentId = null) {
      try {
        this.setData({ loading: true })
        
        // 检查缓存
        const cacheKey = parentId ? `${level}_${parentId}` : level
        if (this.data.regionsCache[cacheKey]) {
          this.setData({
            currentList: this.data.regionsCache[cacheKey],
            loading: false
          })
          return
        }
        
        let result
        
        // 根据级别调用不同接口
        switch (level) {
          case 1: // 省份
            result = await RegionService.getRegionList({ level: 1, limit: 100 })
            break
          case 2: // 城市
            if (parentId) {
              result = await RegionService.getProvincesCities(parentId)
            }
            break
          case 3: // 区县
            if (parentId) {
              result = await RegionService.getCitiesDistricts(parentId)
            }
            break
          case 4: // 街道
            if (parentId) {
              result = await RegionService.getDistrictsStreets(parentId)
            }
            break
          case 5: // 小区
            if (parentId) {
              result = await RegionService.getStreetsCommunities(parentId)
            }
            break
          case 6: // 楼栋
            if (parentId) {
              result = await RegionService.getCommunitiesBuildings(parentId)
            }
            break
          case 7: // 门牌
            if (parentId) {
              result = await RegionService.getBuildingsRooms(parentId)
            }
            break
        }
        
        const list = result?.data?.regions || result?.data?.cities || result?.data?.districts || 
                    result?.data?.streets || result?.data?.communities || result?.data?.buildings || 
                    result?.data?.rooms || []
        
        // 缓存数据
        const regionsCache = this.data.regionsCache
        regionsCache[cacheKey] = list
        
        this.setData({
          currentList: list,
          regionsCache,
          loading: false
        })
        
      } catch (error) {
        console.error('加载区域数据失败:', error)
        this.setData({ 
          currentList: [],
          loading: false 
        })
        
        wx.showToast({
          title: '加载失败',
          icon: 'none'
        })
      }
    },
    
    /**
     * 标签点击
     */
    async onTabTap(e) {
      const { level } = e.currentTarget.dataset
      
      if (level > this.data.selectedPath.length + 1) {
        return // 不能跳级选择
      }
      
      this.setData({ currentLevel: level })
      
      // 加载对应级别数据
      const parentId = level > 1 ? this.data.selectedPath[level - 2]?.id : null
      await this.loadRegionData(level, parentId)
    },
    
    /**
     * 选择区域项
     */
    async onItemSelect(e) {
      const item = e.currentTarget.dataset.item
      const { currentLevel } = this.data
      
      this.setData({ selectedId: item.id })
      
      // 更新选择路径
      const selectedPath = this.data.selectedPath.slice(0, currentLevel - 1)
      selectedPath.push(item)
      
      // 更新标签页名称
      const tabs = this.data.tabs
      tabs[currentLevel - 1].name = item.name
      
      this.setData({
        selectedPath,
        tabs
      })
      
      // 如果还有下一级且未达到最大级别，自动切换到下一级
      if (currentLevel < this.data.maxLevel) {
        const nextLevel = currentLevel + 1
        this.setData({ 
          currentLevel: nextLevel,
          selectedId: null
        })
        
        // 加载下一级数据
        await this.loadRegionData(nextLevel, item.id)
      }
    },
    
    /**
     * 确认选择
     */
    onConfirm() {
      const { selectedPath } = this.data
      
      this.triggerEvent('confirm', {
        selectedPath,
        selectedText: selectedPath.map(item => item.name).join('')
      })
      
      this.onClose()
    },
    
    /**
     * 关闭选择器
     */
    onClose() {
      this.setData({ show: false })
      this.triggerEvent('close')
    },
    
    /**
     * 遮罩点击
     */
    onMaskTap() {
      this.onClose()
    }
  },

  /**
   * 计算属性
   */
  computed: {
    canConfirm() {
      return this.data.selectedPath.length > 0
    }
  }
})
